Please address the comments from this code review:
## Individual Comments

### Comment 1
<location> `src/BootstrapBlazor/Components/SelectGeneric/MultiSelectGeneric.razor.cs:15` </location>
<code_context>
 /// </summary>
 [ExcludeFromCodeCoverage]
-public partial class MultiSelectGeneric<TValue>
+public partial class MultiSelectGeneric<TValue> : IModelEqualityComparer<TValue>
 {
     private List<SelectedItem<TValue>> SelectedItems { get; } = [];
</code_context>

<issue_to_address>
Consider removing the interface and attribute-based comparison logic in favor of a single comparer delegate parameter with a sensible default.

```suggestion
// 1. Remove the IModelEqualityComparer<TValue> implementation, the explicit interface, CustomKeyAttribute,
//    and the Equals(x,y) override. 
// 2. Expose a single comparer parameter (Func<TValue, TValue, bool>) with a default to EqualityComparer<TValue>.Default.
//
// Before:
public partial class MultiSelectGeneric<TValue> : IModelEqualityComparer<TValue>
{
    [Parameter]
    public Func<TValue, TValue, bool>? ValueEqualityComparer { get; set; }

    Func<TValue, TValue, bool>? IModelEqualityComparer<TValue>.ModelEqualityComparer
    {
        get => ValueEqualityComparer;
        set => ValueEqualityComparer = value;
    }

    [Parameter]
    public Type? CustomKeyAttribute { get; set; } = typeof(KeyAttribute);

    public bool Equals(TValue? x, TValue? y) => this.Equals<TValue>(x, y);

    // …lots of extra indirection…
}

// After:
public partial class MultiSelectGeneric<TValue>
{
    /// <summary>
    /// Compare two TValue instances. Defaults to default equality.
    /// </summary>
    [Parameter]
    public Func<TValue, TValue, bool> ValueComparer { get; set; }
        = (x, y) => EqualityComparer<TValue>.Default.Equals(x, y);

    // In your selection logic:
    protected override void OnParametersSet()
    {
        SelectedItems.Clear();
        if (Value != null)
        {
            foreach (var v in Value)
            {
                // no more CustomKeyAttribute or interface indirection
                var item = Rows.Find(i => ValueComparer(i.Value!, v!));
                if (item != null)
                {
                    SelectedItems.Add(item);
                }
            }
        }
    }
}
```
This preserves all functionality, removes the extra interface and attribute-type plumbing, and uses a single, straightforward comparer delegate.
</issue_to_address>